package data.hullmods;

import com.fs.starfarer.api.combat.BaseHullMod;
import com.fs.starfarer.api.combat.MutableShipStatsAPI;
import com.fs.starfarer.api.combat.ShipAPI;
import com.fs.starfarer.api.combat.WeaponAPI;
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.combat.CombatEngineAPI;
import com.fs.starfarer.api.combat.DamageType;
import com.fs.starfarer.api.util.Misc;

import org.lwjgl.util.vector.Vector2f;
import java.awt.Color;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

//modifyMult增加多少倍
//modifyFlat增加多少数值 

//以下为船体增强
public class Super_Plug extends BaseHullMod 
{
	// ===================== 恢复参数 =====================
	// 每秒恢复比例（装甲每格 + 最大值的 X%，结构 + 最大值的 X%）
	private static final float REGEN_PER_SEC = 0.05f;  // 5% 每秒（可调整，0.05f = 5%）

	// ===================== 新增：方案A（技能系统冷却/回充/次数） =====================
	// 注意：方案A是在创建舰船时生效，作用于“安装了该HullMod的船”，与阵营无关
	// 冷却时间倍率（越小越快；0f=真·无冷却；推荐先用0.25f测试）
	private static final float SYSTEM_COOLDOWN_MULT = 0f; // 可改为 0f -> 0CD
	// 回充速度倍率（仅对“有充能”的系统生效）
	private static final float SYSTEM_REGEN_MULT    = 10f;    // 2f=两倍回充
	// 额外可用次数（仅对“有充能”的系统生效；也可用 modifyMult 视SDK版本）
	private static final float SYSTEM_USES_FLAT     = 0f;    // 额外 +1 次

	// ===================== 过载触发开关 =====================
	private static final boolean RING_ON_OVERLOAD_ENABLED = true; // 总开关

	// ===================== 死亡爆炸参数（卢德式自毁效果） =====================
	// 伤害倍率（相对舰船最大结构值，中心最高，向外衰减）
	private static final float DEATH_DAMAGE_MULT = 2.5f;  
	private static final float DEATH_EXPLOSION_RADIUS = 1600f;  // 最大影响半径

	// 视觉 & 动画参数（初始大爆炸）
	private static final float DEATH_BIG_EXPLOSION_SIZE = 800f;
	private static final float DEATH_SMALL_EXPLOSION_SIZE = 500f;

	// 过载环蓝色视觉
	private static final Color RING_FRINGE_COLOR  = new Color(140, 220, 255, 210); // 外沿色
	private static final Color RING_CORE_COLOR    = new Color(255, 255, 255, 240); // 核心色
	private static final Color SHOCKWAVE_COLOR    = new Color(90, 200, 255, 120);  // 冲击波淡蓝
	private static final Color SPARK_COLOR        = new Color(255, 230, 160, 220); // 金色余烬

	// 死亡橙色火焰视觉
	private static final Color DEATH_BIG_COLOR    = new Color(255, 140, 0, 255); // 大爆炸橙
	private static final Color DEATH_SMALL_COLOR  = Color.YELLOW; // 小爆炸黄
	private static final Color DEATH_PARTICLE_COLOR = new Color(255, 200, 100, 255); // 粒子亮橙

	// 纯辐能堆积参数（不造成装甲/结构伤害）
	private static final float   RING_FLUX_MIN    = 0.5f;
	private static final float   RING_FLUX_MAX    = 2.0f;
	private static final boolean RING_FLUX_HARD   = true;
	private static final float   RING_BAND_WIDTH  = 120f;

	// ===================== 性能开关（仅限本环形特效） =====================
	private static final float RING_MAX_RENDER_DISTANCE = 2000f;
	private static final float RING_VIS_STEP_SECONDS    = 0.1f;  // 步进0.1s

	// 弹药补满延迟（用完后等待秒数）
	private static final float AMMO_REGEN_DELAY = 10f;  // 用完后10秒补满

	// 过载环固定参数（避免Janino问题）
	private static final float RING_DURATION_VAL = 3f;
	private static final float RING_MAX_RADIUS_VAL = 1600f;
	private static final float RING_THICKNESS_VAL = 30f;
	private static final int   RING_ARCS_VAL = 8;
	private static final int   RING_DOTS_VAL = 36;
	private static final int   SPARKS_VAL = 20;

	// 统一ShipData
	private static class ShipData {
		float regenT = 0f;
		float ringT = -1f;
		float visT = 0f;
		boolean prevOver = false;
		boolean spawnedShock = false;
		boolean explosionTriggered = false;  // 防止重复触发
		float prevHitpoints = -1f;  // 上一帧HP，用于精确检测死亡瞬间
		float fluxMaxCache = -1f;
		float maxHull = -1f;
		float collRadiusCache = -1f;
		WeaponAPI[] weaponsCache = null;
		float[][] armorGridCache = null;
		float cellMaxCache = -1f;
		
		Map<String, Object> weaponAmmoTimer = new HashMap<String, Object>();
	}

	private static final String SHIP_DATA_KEY = "superplug_shipdata_";

	@Override
	public void applyEffectsBeforeShipCreation(ShipAPI.HullSize hullSize, MutableShipStatsAPI stats, String id) 
	{
		stats.getCombatEngineRepairTimeMult().modifyMult(id, 1f);			//战斗修理引擎时间
		stats.getCombatWeaponRepairTimeMult().modifyMult(id, 1f);			//战斗修理武器时间

		stats.getBaseCRRecoveryRatePercentPerDay().modifyMult(id, 1f);	//基础日CR恢复速度			
		stats.getMaxCombatReadiness().modifyMult(id, 2f);				//CR最大值			
		stats.getRepairRatePercentPerDay().modifyMult(id, 1f);			//基础日修理率
			
		stats.getBeamWeaponDamageMult().modifyMult(id, 1f);             //光束类武器伤害
		stats.getEnergyWeaponDamageMult().modifyMult(id, 1f);           //能量类武器伤害
		stats.getBallisticWeaponDamageMult().modifyMult(id, 1f);        //实弹类武器伤害
		stats.getMissileWeaponDamageMult().modifyMult(id, 1f);          //导弹类武器伤害
					
		stats.getEnergyWeaponFluxCostMod().modifyMult(id, 0.1f);		//能量武器幅能消耗
		stats.getBallisticWeaponFluxCostMod().modifyMult(id, 0.1f);		//实弹武器幅能消耗
		stats.getMissileWeaponFluxCostMod().modifyMult(id, 0.1f);		//导弹类武器幅能消耗
		stats.getBeamWeaponFluxCostMult().modifyMult(id, 0.1f);			//光束武器幅能消耗
		
		stats.getMissileRoFMult().modifyMult(id, 10f);					//导弹重装速度
		stats.getBallisticRoFMult().modifyMult(id, 10f);					//实弹重装速度
		stats.getEnergyRoFMult().modifyMult(id, 10f);					//能量重装速度
		
		stats.getProjectileSpeedMult().modifyMult(id, 1.5f);			//武器弹丸类抛射速度

		stats.getBallisticWeaponRangeBonus().modifyMult(id, 1f);		//实弹武器射程
		stats.getBeamWeaponRangeBonus().modifyFlat(id, 1000f);			   //光束武器射程
		stats.getEnergyWeaponRangeBonus().modifyMult(id, 1f);			//能量武器射程
		stats.getMissileWeaponRangeBonus().modifyMult(id, 1f);          //导弹类武器射程

		stats.getBeamPDWeaponRangeBonus().modifyFlat(id, 1000f);			//光束类PD射程
		stats.getNonBeamPDWeaponRangeBonus().modifyFlat(id, 1000f);		//非光束类PD射程
		
		stats.getWeaponTurnRateBonus().modifyMult(id, 1f);				//武器旋转速率		
		stats.getBeamWeaponTurnRateBonus().modifyMult(id, 1f);			//光束武器旋转速率
		stats.getSightRadiusMod().modifyMult(id, 10f);					//视野半径

		stats.getWeaponHealthBonus().modifyMult(id, 1f);				//武器血量
		stats.getEngineHealthBonus().modifyMult(id, 1f);				//引擎血量
		stats.getEngineDamageTakenMult().modifyMult(id, 1f);			//引擎受到伤害

		stats.getBallisticAmmoBonus().modifyMult(id, 10f);				//实弹弹药
		stats.getEnergyAmmoBonus().modifyMult(id, 10f);				//能量弹药
		stats.getMissileAmmoBonus().modifyMult(id, 2f);				//导弹弹药
		
		stats.getMissileHealthBonus().modifyMult(id, 10f);				//导弹生命值
		stats.getMissileMaxSpeedBonus().modifyMult(id, 1f);				//导弹最大速度加成
		stats.getMissileAccelerationBonus().modifyMult(id, 1f);			//导弹加速度
		stats.getMissileMaxTurnRateBonus().modifyMult(id, 1f);			//导弹最大转向速度
		stats.getMissileTurnAccelerationBonus().modifyMult(id, 1f);		//导弹转向加速度
		stats.getMissileGuidance().modifyMult(id, 1f);					//导弹制导
		
		stats.getAutofireAimAccuracy().modifyMult(id, 1f);					//自动开火准确率
		stats.getMaxRecoilMult().modifyMult(id, 1f);						//最大后座力
		stats.getRecoilPerShotMult().modifyMult(id, 1f);					//每击后座力

		stats.getMaxSpeed().modifyMult(id, 1f);							//最大速度
		stats.getFuelMod().modifyMult(id, 10f);							//携带燃油量
		stats.getCargoMod().modifyMult(id, 10f);							//货仓量（倍率）
		stats.getMaxCrewMod().modifyMult(id, 1f);	                    //载员数量
		stats.getMinCrewMod().modifyMult(id, 0.1f); 					//最小船员数量
		stats.getMaxBurnLevel().modifyMult(id, 1.5f);						//最大航行速度
		stats.getFuelUseMod().modifyMult(id, 0.1f);						//燃油消耗量
		stats.getSuppliesPerMonth().modifyMult(id, 1f);   			    //基础补给消耗
		stats.getCRPerDeploymentPercent().modifyMult(id, 1f);			//每次参战CR消耗
	

		stats.getFluxCapacity().modifyMult(id, 1f);						//Flux总量
		stats.getFluxDissipation().modifyMult(id, 1f);					//Flux消退速率
		stats.getVentRateMult().modifyMult(id, 1f);					    //强制Flux消散速度

		stats.getAcceleration().modifyMult(id, 1f);						//加速度
		stats.getDeceleration().modifyMult(id, 1f);						//减速
		stats.getTurnAcceleration().modifyMult(id, 1f);					//转向加速度
		stats.getMaxTurnRate().modifyMult(id, 1f);						//最大转向速率
		stats.getZeroFluxSpeedBoost().modifyMult(id, 1.5f);				//0幅能时船速

		stats.getShieldArcBonus().modifyMult(id, 1f);					//盾弧度
		stats.getShieldUpkeepMult().modifyMult(id, 1f);					//保持护盾能量消耗
		stats.getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
		stats.getShieldTurnRateMult().modifyMult(id, 1f);				//护盾转向速度
		stats.getShieldUnfoldRateMult().modifyMult(id, 1f);			//护盾打开速度
		
		
		stats.getPeakCRDuration().modifyMult(id, 10f);					//CR峰值持续时间
		stats.getCRLossPerSecondPercent().modifyMult(id, 1f);		    //CR消退速度
		stats.getOverloadTimeMod().modifyMult(id, 1f);				//舰船过载时间

		stats.getHullBonus().modifyMult(id, 1f);                        //耐久,结构
		stats.getArmorBonus().modifyMult(id, 1f);                        //装甲
		stats.getSensorStrength().modifyMult(id, 10f);                   //雷达范围
		stats.getSuppliesToRecover().modifyMult(id, 1f);                 // 修复补给消耗
		
		stats.getFighterRefitTimeMult().modifyMult(id, 0.1f);      		//战机整备速率回复时间
		stats.getNumFighterBays().modifyMult(id, 3f);					//加倍战机数量槽
		stats.getCrewLossMult().modifyMult(id, 0.1f);					//舰船人员战损倍数	
		stats.getFighterWingRange().modifyMult(id, 2f);					//战机交战范围

		stats.getSystemCooldownBonus().modifyMult(id, SYSTEM_COOLDOWN_MULT); // 技能冷却倍率（0f=0CD）
		stats.getSystemRegenBonus().modifyMult(id, SYSTEM_REGEN_MULT);       //技能回充倍率（仅有充能的系统）
		stats.getSystemUsesBonus().modifyFlat(id, SYSTEM_USES_FLAT);         //额外可用次数（仅有充能的系统）
	}
	
	public void applyEffectsToFighterSpawnedByShip( ShipAPI fighter, ShipAPI ship, String id )
	{
		fighter.getMutableStats().getBeamWeaponDamageMult().modifyMult(id, 1f);             //光束类武器伤害
		fighter.getMutableStats().getEnergyWeaponDamageMult().modifyMult(id, 1f);           //能量类武器伤害
		fighter.getMutableStats().getBallisticWeaponDamageMult().modifyMult(id, 1f);        //实弹类武器伤害
		fighter.getMutableStats().getMissileWeaponDamageMult().modifyMult(id, 1f);          //导弹类武器伤害
	
		fighter.getMutableStats().getProjectileSpeedMult().modifyMult(id, 1.5f);			//武器弹丸类抛射速度
		fighter.getMutableStats().getBallisticWeaponRangeBonus().modifyMult(id, 1f);		//实弹武器射程
		fighter.getMutableStats().getBeamWeaponRangeBonus().modifyFlat(id, 1000f);			   //光束武器射程
		fighter.getMutableStats().getEnergyWeaponRangeBonus().modifyMult(id, 1f);			//能量武器射程
		fighter.getMutableStats().getMissileWeaponRangeBonus().modifyMult(id, 1f);          //导弹类武器射程
		
		fighter.getMutableStats().getMissileRoFMult().modifyMult(id, 10f);					//导弹重装速度
		fighter.getMutableStats().getBallisticRoFMult().modifyMult(id, 10f);					//实弹重装速度
		fighter.getMutableStats().getEnergyRoFMult().modifyMult(id, 10f);					//能量重装速度
		
		fighter.getMutableStats().getBallisticAmmoBonus().modifyMult(id, 10f);			//实弹弹药
		fighter.getMutableStats().getEnergyAmmoBonus().modifyMult(id, 10f);				//能量弹药
		fighter.getMutableStats().getMissileAmmoBonus().modifyMult(id, 10f);			//导弹弹药
		
		fighter.getMutableStats().getEnergyWeaponFluxCostMod().modifyMult(id, 0f);			//能量武器幅能消耗
		fighter.getMutableStats().getBallisticWeaponFluxCostMod().modifyMult(id, 0f);		//实弹武器幅能消耗
		fighter.getMutableStats().getMissileWeaponFluxCostMod().modifyMult(id, 0f);			//导弹类武器幅能消耗
		fighter.getMutableStats().getBeamWeaponFluxCostMult().modifyMult(id, 0f);			//光束武器幅能消耗
		
		fighter.getMutableStats().getMaxSpeed().modifyMult(id, 3f);							//最大速度
		fighter.getMutableStats().getAcceleration().modifyMult(id, 3f);						//加速度
		fighter.getMutableStats().getDeceleration().modifyMult(id, 3f);						//减速
		fighter.getMutableStats().getTurnAcceleration().modifyMult(id, 3f);					//转向加速度
		fighter.getMutableStats().getMaxTurnRate().modifyMult(id, 3f);						//最大转向速率
		
		fighter.getMutableStats().getArmorBonus().modifyMult(id, 1f);                        //装甲
		fighter.getMutableStats().getHullBonus().modifyMult(id, 1f);                        //耐久,结构
		fighter.getMutableStats().getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
		
		fighter.getMutableStats().getMissileHealthBonus().modifyMult(id, 10f);				//导弹生命值
		fighter.getMutableStats().getMissileMaxSpeedBonus().modifyMult(id, 1f);				//导弹最大速度加成
		fighter.getMutableStats().getMissileAccelerationBonus().modifyMult(id, 1f);			//导弹加速度
		fighter.getMutableStats().getMissileMaxTurnRateBonus().modifyMult(id, 1f);			//导弹最大转向速度
		fighter.getMutableStats().getMissileTurnAccelerationBonus().modifyMult(id, 1f);		//导弹转向加速度
		fighter.getMutableStats().getMissileGuidance().modifyMult(id, 1f);					//导弹制导
	}

	public void advanceInCombat(ShipAPI ship, float amount) 
	{
		CombatEngineAPI engine = Global.getCombatEngine();
		if (engine == null || engine.isPaused()) return;

		ShipData data = getShipData(engine, ship.getId());

		// 缓存
		if (data.fluxMaxCache < 0f) data.fluxMaxCache = ship.getFluxTracker().getMaxFlux();
		if (data.maxHull < 0f) data.maxHull = ship.getMaxHitpoints();
		if (data.collRadiusCache < 0f) data.collRadiusCache = ship.getCollisionRadius();
		if (data.prevHitpoints < 0f) data.prevHitpoints = ship.getHitpoints();
		if (data.weaponsCache == null) {
			List<WeaponAPI> tempList = ship.getAllWeapons();
			WeaponAPI[] tempArray = new WeaponAPI[tempList.size()];
			tempList.toArray(tempArray);
			data.weaponsCache = tempArray;
		}
		if (data.armorGridCache == null && ship.getArmorGrid() != null) {
			data.armorGridCache = ship.getArmorGrid().getGrid();
			data.cellMaxCache = ship.getArmorGrid().getMaxArmorInCell();
		}

		// ===================== 死亡瞬间爆炸（可靠触发） =====================
		float currentHP = ship.getHitpoints();
		if (currentHP <= 0f && data.prevHitpoints > 0f && !data.explosionTriggered) {
			data.explosionTriggered = true;

			Vector2f loc = ship.getLocation();
			Vector2f vel = ship.getVelocity();

			// 视觉：纯橙色火焰爆炸（已去除白光闪）
			engine.spawnExplosion(loc, vel, DEATH_BIG_COLOR, DEATH_BIG_EXPLOSION_SIZE * 1.2f, 5f);
			engine.spawnExplosion(loc, vel, DEATH_SMALL_COLOR, DEATH_SMALL_EXPLOSION_SIZE * 1.5f, 4f);
			engine.addSmoothParticle(loc, vel, 1200f, 2f, 4f, DEATH_PARTICLE_COLOR);
			engine.addHitParticle(loc, vel, 1500f, 1f, 5f, DEATH_PARTICLE_COLOR);

			// 范围高爆伤害
			List<ShipAPI> ships = engine.getShips();
			for (ShipAPI other : ships) {
				if (other == null || !other.isAlive() || other.getOwner() == ship.getOwner() || other == ship) continue;

				float dist = Misc.getDistance(loc, other.getLocation());
				if (dist > DEATH_EXPLOSION_RADIUS) continue;

				float t = 1f - (dist / DEATH_EXPLOSION_RADIUS);
				float damage = data.maxHull * DEATH_DAMAGE_MULT * t;

				if (damage > 0f) {
					engine.applyDamage(other, other.getLocation(), damage, DamageType.HIGH_EXPLOSIVE, 0f, true, false, ship);
				}
			}
		}
		data.prevHitpoints = currentHP;

		// ===================== 正常活着时的逻辑 =====================
		if (ship.isAlive()) {
			// 恢复
			data.regenT += amount;
			while (data.regenT >= 1f) {  
				data.regenT -= 1f;

				float hullAdd = data.maxHull * REGEN_PER_SEC;
				float newHull = Math.min(ship.getHitpoints() + hullAdd, data.maxHull);
				ship.setHitpoints(newHull);

				if (data.armorGridCache != null && data.cellMaxCache > 0f) {
					float armorAdd = data.cellMaxCache * REGEN_PER_SEC;
					for (float[] row : data.armorGridCache) {
						for (int i = 0; i < row.length; i++) {
							row[i] = Math.min(row[i] + armorAdd, data.cellMaxCache);
						}
					}
					ship.syncWithArmorGridState();
				}
			}

			// 弹药
			if (data.weaponsCache != null) {
				for (WeaponAPI w : data.weaponsCache) {
					if (w != null && w.usesAmmo() && w.getMaxAmmo() > 0) {  
						String wid = w.getSlot().getId() + "_" + ship.getId();  
						
						if (w.getAmmo() == 0) {
							Object o = data.weaponAmmoTimer.get(wid);
							float timer = 0f;
							if (o instanceof Float) {
								timer = (Float) o;
							}
							timer += amount;
							data.weaponAmmoTimer.put(wid, timer);
							
							if (timer >= AMMO_REGEN_DELAY) {
								w.setAmmo(w.getMaxAmmo());
								data.weaponAmmoTimer.remove(wid);  
							}
						} else {
							data.weaponAmmoTimer.remove(wid);
						}
					}
				}
			}

			// 过载环
			if (RING_ON_OVERLOAD_ENABLED) {
				if (ship.getFluxTracker() != null) {
					boolean isOver = ship.getFluxTracker().isOverloaded();
					if (isOver && !data.prevOver) {
						data.ringT = 0f;
						data.visT = 0f;
						data.spawnedShock = false;
					}
					data.prevOver = isOver;

					if (data.ringT >= 0f) {
						data.ringT += amount;

						float duration = RING_DURATION_VAL;
						if (data.ringT >= duration) {
							data.ringT = -1f;
						}

						data.visT += amount;
						float step = RING_VIS_STEP_SECONDS;
						if (data.visT >= step) {
							data.visT = 0f;

							ShipAPI player = engine.getPlayerShip();
							boolean farAway = player == null || Misc.getDistance(ship.getLocation(), player.getLocation()) > RING_MAX_RENDER_DISTANCE;

							Vector2f center = ship.getLocation();
							float progress = data.ringT / duration;
							float curR = RING_MAX_RADIUS_VAL * progress;

							if (!farAway) {
								if (!data.spawnedShock) {
									data.spawnedShock = true;
									engine.spawnExplosion(center, new Vector2f(), Color.WHITE, 
										Math.max(120f, data.collRadiusCache * 0.6f), 0.25f);
									engine.addSmoothParticle(center, new Vector2f(), 
										Math.max(200f, data.collRadiusCache), 1.2f, 0.15f, new Color(255,240,220,255));
								}

								float ringSize = 30f + curR * 0.06f;
								float bright = 0.8f * (1f - progress);
								int dots = RING_DOTS_VAL;
								for (int i = 0; i < dots; i++) {
									float ang = (360f / dots) * i + (float)Math.random() * 4f;
									float rad = (float) Math.toRadians(ang);
									Vector2f loc = new Vector2f(center.x + (float)Math.cos(rad) * curR, center.y + (float)Math.sin(rad) * curR);
									engine.addSmoothParticle(loc, new Vector2f(), ringSize, bright, 0.4f, SHOCKWAVE_COLOR);
								}

								float baseAng = engine.getTotalElapsedTime(false) * 120f % 360f;
								int arcs = RING_ARCS_VAL;
								for (int i = 0; i < arcs; i++) {
									float ang = baseAng + (360f / arcs) * i + (float)Math.random() * 8f;
									float rad = (float) Math.toRadians(ang);
									Vector2f loc = new Vector2f(center.x + (float)Math.cos(rad) * curR, center.y + (float)Math.sin(rad) * curR);
									engine.spawnEmpArcVisual(center, ship, loc, null, RING_THICKNESS_VAL, RING_FRINGE_COLOR, RING_CORE_COLOR);
								}

								int sparks = SPARKS_VAL;
								for (int i = 0; i < sparks; i++) {
									float ang = (float)(Math.random() * 360f);
									float rad = (float) Math.toRadians(ang);
									Vector2f loc = new Vector2f(center.x + (float)Math.cos(rad) * curR, center.y + (float)Math.sin(rad) * curR);
									Vector2f vel = new Vector2f((float)Math.cos(rad) * (80f + (float)Math.random()*120f), (float)Math.sin(rad) * (80f + (float)Math.random()*120f));
									float size = 6f + (float)Math.random()*10f;
									engine.addHitParticle(loc, vel, size, 0.8f, 0.35f + (float)Math.random()*0.4f, SPARK_COLOR);
								}
							}

							if (data.fluxMaxCache > 0f) {
								float bandHalf = RING_BAND_WIDTH * 0.5f;
								List<ShipAPI> shipsList = engine.getShips();
								for (ShipAPI other : shipsList) {
									if (other == null || !other.isAlive() || other.getOwner() == ship.getOwner()) continue;
									float dist = Misc.getDistance(center, other.getLocation());
									if (Math.abs(dist - curR) > bandHalf) continue;

									float edge = Math.abs(dist - curR) / bandHalf;
									float t = Math.max(0f, 1f - edge);
									float flux = data.fluxMaxCache * (RING_FLUX_MIN + (RING_FLUX_MAX - RING_FLUX_MIN) * t);
									if (flux > 0f) other.getFluxTracker().increaseFlux(flux, RING_FLUX_HARD);
								}
							}
						}
					}
				}
			}
		}
	}
	
	private ShipData getShipData(CombatEngineAPI engine, String shipId) {
		String key = SHIP_DATA_KEY + shipId;
		Object obj = engine.getCustomData().get(key);
		if (obj instanceof ShipData) return (ShipData) obj;
		ShipData data = new ShipData();
		engine.getCustomData().put(key, data);
		return data;
	}
}